class Solution {
    public int findKthLargest(int[] nums, int k) {
        int heapSize = nums.length;
        buildMaxHeap(nums, heapSize);  // 构建最大堆
        for (int i = nums.length - 1; i >= nums.length - k + 1; --i) {
            swap(nums, 0, i);  // 将堆顶元素与当前未排序部分的最后一个元素交换
            --heapSize;  // 缩小堆的大小
            maxHeapify(nums, 0, heapSize);  // 调整堆使其继续满足最大堆的性质
        }
        return nums[0];  // 返回第k个最大元素（堆顶元素）
    }

    // 构建最大堆
    public void buildMaxHeap(int[] a, int heapSize) {
        for (int i = heapSize / 2; i >= 0; --i) {
            maxHeapify(a, i, heapSize);  // 对每个非叶子节点进行调整，使其满足最大堆的性质
        }
    }

    // 调整以i为根节点的子树，使其满足最大堆的性质
    public void maxHeapify(int[] a, int i, int heapSize) {
        //计算左右节点的下标
        int left = i * 2 + 1, right = i * 2 + 2, largest = i;
        // 下沉操作：比较节点i与其左右子节点的值，找到最大值
        // 先与左节点对比
        if (left < heapSize && a[left] > a[largest]) {
            largest = left;
        }
        // 再与右节点对比
        if (right < heapSize && a[right] > a[largest]) {
            largest = right;
        }
        if (largest != i) {
            swap(a, i, largest);  // 将节点i与最大值节点交换位置
            maxHeapify(a, largest, heapSize);  // 继续向下调整以保持最大堆的性质
        }
    }

    // 交换数组中两个元素的位置
    public void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}